'use strict';

const fs = require('fs');
const path = require('path');
const XLSX = require('xlsx');
const csv = require('csv-parser');

class SupplierService {
  constructor(ctx) {
    this.ctx = ctx;
  }

  /**
   * 获取供应商列表
   */
  async getSupplierList(query) {
    const { page = 1, limit = 20, name, status, category, riskLevel } = query;
    
    // 构建查询条件
    const where = {};
    
    // 添加组织过滤条件
    if (this.ctx.state.organizationId) {
      where.organizationId = this.ctx.state.organizationId;
    } else {
      where.organizationId = 1; // 默认组织ID
      this.ctx.logger.warn('未找到组织ID，使用默认组织ID: 1。当前用户状态:', 
                          'organizationId:', this.ctx.state.organizationId);
    }
    
    if (name) {
      where.name = { [this.ctx.app.Sequelize.Op.like]: `%${name}%` };
    }
    if (status) {
      where.status = status;
    }
    if (category) {
      where.category = category;
    }
    if (riskLevel) {
      where.riskLevel = riskLevel;
    }

    try {
      this.ctx.logger.info('查询条件:', where);
      // 分页查询
      const offset = (parseInt(page) - 1) * parseInt(limit);
      
      const result = await this.ctx.model.SupplierModel.findAndCountAll({
        where,
        order: [['createdAt', 'DESC']],
        limit: parseInt(limit),
        offset
      });

      return {
        list: result.rows,
        pagination: {
          page: parseInt(page),
          limit: parseInt(limit),
          total: result.count,
          totalPages: Math.ceil(result.count / parseInt(limit))
        }
      };
    } catch (error) {
      this.ctx.logger.error('数据库查询供应商列表失败:', error);
      // 如果是数据库连接错误，返回模拟数据而不是直接失败
      if (error.name === 'SequelizeConnectionRefusedError' || 
          error.name === 'SequelizeAccessDeniedError' ||
          error.name === 'SequelizeHostNotFoundError') {
        // 返回模拟数据
        this.ctx.logger.warn('数据库连接失败，返回模拟数据');
        return {
          list: [
            {
              id: 1,
              organizationId: 1,
              name: '示例供应商1',
              contactPerson: '张经理',
              phone: '13800138001',
              email: 'zhang@example.com',
              address: '北京市朝阳区示例街道1号',
              remark: '示例供应商备注',
              status: 'active',
              rating: 4.5,
              cooperationDate: '2025-01-01T00:00:00.000Z',
              createdAt: '2025-01-01T00:00:00.000Z',
              updatedAt: '2025-01-01T00:00:00.000Z'
            },
            {
              id: 2,
              organizationId: 1,
              name: '示例供应商2',
              contactPerson: '李经理',
              phone: '13800138002',
              email: 'li@example.com',
              address: '上海市浦东新区示例街道2号',
              remark: '示例供应商备注2',
              status: 'pending',
              rating: 3.8,
              cooperationDate: '2025-02-01T00:00:00.000Z',
              createdAt: '2025-02-01T00:00:00.000Z',
              updatedAt: '2025-02-01T00:00:00.000Z'
            }
          ],
          pagination: {
            page: parseInt(page),
            limit: parseInt(limit),
            total: 2,
            totalPages: 1
          }
        };
      }
      throw new Error('获取供应商列表失败: ' + error.message);
    }
  }

  /**
   * 获取供应商详情
   */
  async getSupplierById(id) {
    try {
      // 验证参数
      const rule = {
        id: { type: 'int', required: true, min: 1 }
      };
      
      // 转换id为整数
      const supplierId = parseInt(id);
      this.ctx.validate(rule, { id: supplierId });
      
      const supplier = await this.ctx.model.SupplierModel.findOne({
        where: {
          id: supplierId,
          organizationId: this.ctx.state.organizationId || 1
        }
      });
      
      if (!supplier) {
        throw new Error('供应商不存在');
      }
      
      return supplier;
    } catch (error) {
      this.ctx.logger.error('获取供应商详情失败:', error);
      if (error.errors) {
        throw new Error(`参数验证失败: ${error.errors.map(e => e.message).join(', ')}`);
      } else {
        throw new Error('获取供应商详情失败');
      }
    }
  }

  /**
   * 创建供应商
   */
  async createSupplier(data) {
    try {
      // 验证参数
      const rule = {
        name: { type: 'string', required: true, min: 1, max: 100 },
        contactPerson: { type: 'string', required: false, max: 50, allowEmpty: true },
        phone: { type: 'string', required: false, max: 20, allowEmpty: true },
        email: { type: 'email', required: false, allowEmpty: true },
        address: { type: 'string', required: false, max: 200, allowEmpty: true },
        remark: { type: 'string', required: false, max: 500, allowEmpty: true },
        status: { type: 'enum', values: ['pending', 'active', 'suspended', 'terminated'], required: false, default: 'pending' },
        cooperationDate: { type: 'date', required: false, allowEmpty: true }
      };
      
      this.ctx.validate(rule);
      
      // 处理cooperationDate字段，如果为空字符串则设置为null
      if (data.cooperationDate === '' || data.cooperationDate === 'Invalid date') {
        data.cooperationDate = null;
      }
      
      // 检查供应商名称是否已存在（在同一组织内）
      const existingSupplier = await this.ctx.model.SupplierModel.findOne({
        where: { 
          name: data.name,
          organizationId: this.ctx.state.organizationId || 1
        }
      });
      
      if (existingSupplier) {
        throw new Error('供应商名称已存在');
      }
      
      // 设置组织ID
      data.organizationId = this.ctx.state.organizationId || 1;
      
      const supplier = await this.ctx.model.SupplierModel.create(data);
      
      return supplier;
    } catch (error) {
      this.ctx.logger.error('创建供应商失败:', error);
      if (error.errors) {
        throw new Error(`参数验证失败: ${error.errors.map(e => e.message).join(', ')}`);
      } else {
        throw new Error('创建供应商失败: ' + error.message);
      }
    }
  }

  /**
   * 更新供应商
   */
  async updateSupplier(id, data) {
    try {
      // 验证参数
      const updateRule = {
        name: { type: 'string', required: false, min: 1, max: 100 },
        contactPerson: { type: 'string', required: false, max: 50, allowEmpty: true },
        phone: { type: 'string', required: false, max: 20, allowEmpty: true },
        email: { type: 'email', required: false, allowEmpty: true },
        address: { type: 'string', required: false, max: 200, allowEmpty: true },
        remark: { type: 'string', required: false, max: 500, allowEmpty: true },
        status: { type: 'enum', values: ['pending', 'active', 'suspended', 'terminated'], required: false },
        cooperationDate: { type: 'date', required: false, allowEmpty: true }
      };
      
      this.ctx.validate(updateRule);
      
      // 转换id为整数
      const supplierId = parseInt(id);
      
      // 检查供应商是否存在
      const supplier = await this.ctx.model.SupplierModel.findByPk(supplierId);
      if (!supplier) {
        throw new Error('供应商不存在');
      }
      
      // 如果修改了名称，检查新名称是否已存在
      if (data.name && data.name !== supplier.name) {
        const existingSupplier = await this.ctx.model.SupplierModel.findOne({
          where: { 
            name: data.name,
            id: {
              [this.ctx.app.Sequelize.Op.ne]: supplierId
            },
            organizationId: this.ctx.state.organizationId || 1
          }
        });
      
        if (existingSupplier) {
          throw new Error('供应商名称已存在');
        }
      }
      
      await supplier.update(data);
      return supplier;
    } catch (error) {
      this.ctx.logger.error('更新供应商失败:', error);
      if (error.errors) {
        throw new Error(`参数验证失败: ${error.errors.map(e => e.message).join(', ')}`);
      } else {
        throw new Error('更新供应商失败: ' + error.message);
      }
    }
  }

  /**
   * 删除供应商
   */
  async deleteSupplier(id) {
    try {
      // 验证参数
      const rule = {
        id: { type: 'int', required: true, min: 1 }
      };
      
      // 转换id为整数
      const supplierId = parseInt(id);
      this.ctx.validate(rule, { id: supplierId });
      
      // 检查供应商是否存在
      const supplier = await this.ctx.model.SupplierModel.findOne({
        where: {
          id: supplierId,
          organizationId: this.ctx.state.organizationId || 1
        }
      });
      if (!supplier) {
        throw new Error('供应商不存在');
      }
      
      await supplier.destroy();
      return true;
    } catch (error) {
      this.ctx.logger.error('删除供应商失败:', error);
      throw new Error('删除供应商失败');
    }
  }

  /**
   * 批量删除供应商
   */
  async batchDeleteSuppliers(ids) {
    try {
      // 验证参数
      if (!Array.isArray(ids) || ids.length === 0) {
        throw new Error('请选择要删除的供应商');
      }

      // 验证每个ID是否为有效数字
      for (const id of ids) {
        if (!Number.isInteger(Number(id)) || Number(id) <= 0) {
          throw new Error('供应商ID格式不正确');
        }
      }

      // 添加组织过滤条件
      const orgWhere = {};
      if (this.ctx.state.organizationId) {
        orgWhere.organizationId = this.ctx.state.organizationId;
      } else {
        orgWhere.organizationId = 1; // 默认组织ID
      }

      // 检查要删除的供应商是否都属于当前组织
      const suppliers = await this.ctx.model.SupplierModel.findAll({
        where: {
          id: ids,
          ...orgWhere
        }
      });

      // 如果找到的供应商数量与要删除的ID数量不一致，说明有ID不属于当前组织
      if (suppliers.length !== ids.length) {
        throw new Error('部分供应商不属于当前组织，无法删除');
      }

      // 执行批量删除
      const result = await this.ctx.model.SupplierModel.destroy({
        where: {
          id: ids,
          ...orgWhere
        }
      });

      if (result > 0) {
        return `成功删除${result}个供应商`;
      } else {
        throw new Error('未找到要删除的供应商');
      }
    } catch (error) {
      this.ctx.logger.error('批量删除供应商失败:', error);
      throw new Error('批量删除供应商失败: ' + error.message);
    }
  }

  /**
   * 批量激活供应商
   */
  async batchActivateSuppliers(ids) {
    try {
      // 验证参数
      if (!Array.isArray(ids) || ids.length === 0) {
        throw new Error('请选择要激活的供应商');
      }

      // 验证每个ID是否为有效数字
      for (const id of ids) {
        if (!Number.isInteger(Number(id)) || Number(id) <= 0) {
          throw new Error('供应商ID格式不正确');
        }
      }

      // 添加组织过滤条件
      const orgWhere = {};
      if (this.ctx.state.organizationId) {
        orgWhere.organizationId = this.ctx.state.organizationId;
      } else {
        orgWhere.organizationId = 1; // 默认组织ID
      }

      // 检查要激活的供应商是否都属于当前组织
      const suppliers = await this.ctx.model.SupplierModel.findAll({
        where: {
          id: ids,
          ...orgWhere
        }
      });

      // 如果找到的供应商数量与要激活的ID数量不一致，说明有ID不属于当前组织
      if (suppliers.length !== ids.length) {
        throw new Error('部分供应商不属于当前组织，无法激活');
      }

      // 执行批量更新
      const result = await this.ctx.model.SupplierModel.update(
        { status: 'active' },
        {
          where: {
            id: ids,
            ...orgWhere
          }
        }
      );

      if (result[0] > 0) {
        return `成功激活${result[0]}个供应商`;
      } else {
        throw new Error('未找到要激活的供应商');
      }
    } catch (error) {
      this.ctx.logger.error('批量激活供应商失败:', error);
      throw new Error('批量激活供应商失败: ' + error.message);
    }
  }

  /**
   * 批量停用供应商
   */
  async batchDeactivateSuppliers(ids) {
    try {
      // 验证参数
      if (!Array.isArray(ids) || ids.length === 0) {
        throw new Error('请选择要停用的供应商');
      }

      // 验证每个ID是否为有效数字
      for (const id of ids) {
        if (!Number.isInteger(Number(id)) || Number(id) <= 0) {
          throw new Error('供应商ID格式不正确');
        }
      }

      // 添加组织过滤条件
      const orgWhere = {};
      if (this.ctx.state.organizationId) {
        orgWhere.organizationId = this.ctx.state.organizationId;
      } else {
        orgWhere.organizationId = 1; // 默认组织ID
      }

      // 检查要停用的供应商是否都属于当前组织
      const suppliers = await this.ctx.model.SupplierModel.findAll({
        where: {
          id: ids,
          ...orgWhere
        }
      });

      // 如果找到的供应商数量与要停用的ID数量不一致，说明有ID不属于当前组织
      if (suppliers.length !== ids.length) {
        throw new Error('部分供应商不属于当前组织，无法停用');
      }

      // 执行批量更新
      const result = await this.ctx.model.SupplierModel.update(
        { status: 'suspended' },
        {
          where: {
            id: ids,
            ...orgWhere
          }
        }
      );

      if (result[0] > 0) {
        return `成功停用${result[0]}个供应商`;
      } else {
        throw new Error('未找到要停用的供应商');
      }
    } catch (error) {
      this.ctx.logger.error('批量停用供应商失败:', error);
      throw new Error('批量停用供应商失败: ' + error.message);
    }
  }

  /**
   * 导出供应商
   */
  async exportSuppliers(query) {
    try {
      const { name, contactPerson, phone, email, status, createdAtStart, createdAtEnd } = query;
      
      const where = {};
      
      // 构建查询条件
      if (name) {
        where.name = {
          [this.ctx.app.Sequelize.Op.like]: `%${name}%`
        };
      }
      
      if (contactPerson) {
        where.contactPerson = {
          [this.ctx.app.Sequelize.Op.like]: `%${contactPerson}%`
        };
      }
      
      if (phone) {
        where.phone = {
          [this.ctx.app.Sequelize.Op.like]: `%${phone}%`
        };
      }
      
      if (email) {
        where.email = {
          [this.ctx.app.Sequelize.Op.like]: `%${email}%`
        };
      }
      
      if (status) {
        where.status = status;
      }
      
      // 处理创建时间范围
      if (createdAtStart || createdAtEnd) {
        where.createdAt = {};
        if (createdAtStart) {
          where.createdAt[this.ctx.app.Sequelize.Op.gte] = new Date(createdAtStart);
        }
        if (createdAtEnd) {
          where.createdAt[this.ctx.app.Sequelize.Op.lte] = new Date(createdAtEnd);
        }
      }
      
      // 查询所有供应商
      const suppliers = await this.ctx.model.SupplierModel.findAll({
        where,
        order: [['createdAt', 'DESC']]
      });
      
      // 生成CSV内容
      let csvContent = '\uFEFF'; // 添加BOM以支持中文
      csvContent += '供应商名称,联系人,联系电话,邮箱,地址,状态,合作时间,备注,创建时间\n';
      
      suppliers.forEach(supplier => {
        csvContent += `"${supplier.name || ''}",`;
        csvContent += `"${supplier.contactPerson || ''}",`;
        csvContent += `"${supplier.phone || ''}",`;
        csvContent += `"${supplier.email || ''}",`;
        csvContent += `"${supplier.address || ''}",`;
        csvContent += `"${supplier.status || ''}",`;
        csvContent += `"${supplier.cooperationDate ? new Date(supplier.cooperationDate).toLocaleDateString() : ''}",`;
        csvContent += `"${supplier.remark || ''}",`;
        csvContent += `"${supplier.createdAt ? new Date(supplier.createdAt).toLocaleString() : ''}"\n`;
      });
      
      return csvContent;
    } catch (error) {
      this.ctx.logger.error('导出供应商失败:', error);
      throw new Error('导出供应商失败');
    }
  }

  /**
   * 导入供应商
   */
  async importSuppliers(file, fieldMapping = {}) {
    let tempFilePath = null; // 保存临时文件路径，以便在出错时清理
    const startTime = Date.now(); // 记录开始时间
    
    try {
      this.ctx.logger.info('开始处理供应商导入请求');
      this.ctx.logger.info('接收到的文件对象:', file);
      this.ctx.logger.info('接收到的字段映射:', fieldMapping);
      
      // 安全处理文件名，移除特殊字符
      let safeFilename = file.filename || file.name || 'upload_file.csv';
      // 移除特殊字符，只保留字母、数字、点、下划线和连字符
      safeFilename = safeFilename.replace(/[^a-zA-Z0-9._-]/g, '');
      // 确保文件名不为空
      if (!safeFilename || safeFilename === '.') {
        safeFilename = 'upload_file.csv';
      }
      
      // 确保文件有正确的扩展名（保留原始扩展名）
      const originalExtension = path.extname(file.filename || file.name || '');
      if (originalExtension && !safeFilename.endsWith(originalExtension)) {
        // 如果安全处理后的文件名丢失了扩展名，恢复原始扩展名
        safeFilename = path.basename(safeFilename, path.extname(safeFilename)) + originalExtension;
      }
      
      // 如果仍然没有扩展名，使用默认的.csv
      if (!path.extname(safeFilename)) {
        safeFilename += '.csv';
      }
      
      // 保存上传的文件到临时位置
      tempFilePath = path.join(__dirname, '../../../temp', Date.now() + '_' + safeFilename);
      this.ctx.logger.info('临时文件路径:', tempFilePath);
      
      // 确保临时目录存在
      const tempDir = path.dirname(tempFilePath);
      if (!fs.existsSync(tempDir)) {
        this.ctx.logger.info('创建临时目录:', tempDir);
        fs.mkdirSync(tempDir, { recursive: true });
      }
      
      // 保存文件 - 根据文件对象类型选择合适的方法
      this.ctx.logger.info('开始保存文件');
      if (file.pipe) {
        // 如果是流对象
        this.ctx.logger.info('文件对象是流类型');
        const writeStream = fs.createWriteStream(tempFilePath);
        file.pipe(writeStream);
        
        // 等待文件保存完成
        await new Promise((resolve, reject) => {
          writeStream.on('finish', () => {
            this.ctx.logger.info('文件流保存完成');
            resolve();
          });
          writeStream.on('error', reject);
        });
      } else if (file.filepath) {
        // 如果是Egg.js的文件对象
        this.ctx.logger.info('文件对象是Egg.js类型，源文件路径:', file.filepath);
        // 直接复制文件
        fs.copyFileSync(file.filepath, tempFilePath);
        this.ctx.logger.info('文件复制完成');
      } else {
        // 尝试其他方式保存文件
        this.ctx.logger.info('尝试其他方式保存文件');
        throw new Error('不支持的文件对象类型');
      }
      
      // 检查文件是否保存成功
      if (!fs.existsSync(tempFilePath)) {
        throw new Error('文件保存失败');
      }
      
      const fileStats = fs.statSync(tempFilePath);
      this.ctx.logger.info('文件保存完成，文件大小:', fileStats.size, '字节');
      
      // 如果文件为空，尝试从原始文件路径读取
      if (fileStats.size === 0 && file.filepath) {
        this.ctx.logger.warn('临时文件为空，尝试从原始路径读取');
        const originalStats = fs.statSync(file.filepath);
        this.ctx.logger.info('原始文件大小:', originalStats.size, '字节');
        if (originalStats.size > 0) {
          fs.copyFileSync(file.filepath, tempFilePath);
          this.ctx.logger.info('重新复制文件完成');
        }
      }
      
      // 再次检查文件大小
      const finalStats = fs.statSync(tempFilePath);
      if (finalStats.size === 0) {
        throw new Error('上传的文件为空');
      }
      
      let jsonData = [];
      
      // 根据文件扩展名判断文件类型并解析
      const fileExtension = path.extname(safeFilename).toLowerCase();
      this.ctx.logger.info('文件扩展名:', fileExtension);
      
      if (fileExtension === '.csv') {
        // 解析CSV文件
        this.ctx.logger.info('解析CSV文件');
        jsonData = await new Promise((resolve, reject) => {
          const results = [];
          fs.createReadStream(tempFilePath, { encoding: 'utf8' })
            .pipe(csv({ 
              skipEmptyLines: true,
              // 添加更多解析选项以处理可能的编码问题
              trim: true,
              skipLines: 0,
              maxRows: 0
            }))
            .on('data', (data) => {
              this.ctx.logger.info('原始解析数据:', data);
              // 清理数据，移除可能的"undefined"值
              const cleanedData = {};
              for (const [key, value] of Object.entries(data)) {
                // 移除键和值的空白字符
                const cleanKey = key ? key.trim() : key;
                const cleanValue = value ? value.toString().trim() : '';
                
                // 跳过"undefined"字符串值
                if (cleanValue !== 'undefined') {
                  cleanedData[cleanKey] = cleanValue;
                } else {
                  cleanedData[cleanKey] = '';
                }
              }
              this.ctx.logger.info('清理后数据:', cleanedData);
              results.push(cleanedData);
            })
            .on('end', () => {
              this.ctx.logger.info('CSV解析完成，共', results.length, '行数据');
              resolve(results);
            })
            .on('error', reject);
        });
      } else if (fileExtension === '.xlsx' || fileExtension === '.xls') {
        // 解析Excel文件
        this.ctx.logger.info('解析Excel文件');
        try {
          // 动态导入xlsx库
          const XLSX = require('xlsx');
          
          // 读取文件
          const workbook = XLSX.readFile(tempFilePath);
          
          // 获取第一个工作表
          const firstSheetName = workbook.SheetNames[0];
          const worksheet = workbook.Sheets[firstSheetName];
          
          // 转换为JSON格式
          jsonData = XLSX.utils.sheet_to_json(worksheet, { defval: '' });
          
          this.ctx.logger.info('Excel解析完成，共', jsonData.length, '行数据');
          this.ctx.logger.info('Excel解析数据示例:', jsonData.slice(0, 3));
        } catch (excelError) {
          this.ctx.logger.error('解析Excel文件失败:', excelError);
          throw new Error('解析Excel文件失败: ' + excelError.message);
        }
      } else {
        throw new Error('不支持的文件格式，仅支持CSV、XLSX和XLS格式');
      }
      
      this.ctx.logger.info('解析完成，数据行数:', jsonData.length);
      
      // 验证并处理数据
      const validSuppliers = [];
      const errors = [];
      
      // 分批处理大量数据，避免内存溢出和提高响应速度
      const batchSize = 100; // 每批处理100条记录
      let processedCount = 0;
      
      this.ctx.logger.info(`开始处理数据，总行数: ${jsonData.length}`);
      
      for (let i = 0; i < jsonData.length; i++) {
        const row = jsonData[i];
        const rowIndex = i + 2; // +2 because header is row 1, and Excel is 1-indexed
      
        try {
          this.ctx.logger.info(`处理第${rowIndex}行数据:`, row);
          
          // 根据字段映射关系获取供应商名称
          let supplierName = '';
        
          this.ctx.logger.info('使用字段映射关系查找供应商名称');
          // 检查是否有字段映射关系
          if (Object.keys(fieldMapping).length > 0) {
            this.ctx.logger.info('字段映射关系存在');
            // 查找映射到"name"的列
            for (const [sourceColumn, targetField] of Object.entries(fieldMapping)) {
              this.ctx.logger.info(`检查映射: "${sourceColumn}" -> "${targetField}"`);
              if (targetField === 'name') {
                this.ctx.logger.info(`找到映射到name的列: "${sourceColumn}"`);
                this.ctx.logger.info(`row[sourceColumn] = "${row[sourceColumn]}"`);
                // 检查值是否存在且不为"undefined"字符串
                if (row[sourceColumn] && row[sourceColumn] !== 'undefined') {
                  supplierName = row[sourceColumn];
                  this.ctx.logger.info(`通过字段映射找到供应商名称: "${supplierName}"`);
                  break;
                } else {
                  this.ctx.logger.info(`row[sourceColumn]为空或为undefined字符串`);
                }
              }
            }
          }
          
          // 如果通过字段映射没有找到供应商名称，则尝试默认列名
          if (!supplierName) {
            this.ctx.logger.info('通过字段映射未找到供应商名称，尝试默认列名');
            const defaultName = row['供应商名称'] || row['单位名称'] || row['公司名称'] || row['名称'];
            if (defaultName && defaultName !== 'undefined') {
              supplierName = defaultName;
              this.ctx.logger.info(`通过默认列名找到供应商名称: "${supplierName}"`);
            } else {
              this.ctx.logger.info('通过默认列名也未找到供应商名称');
            }
          }
        
          // 验证必填字段
          this.ctx.logger.info(`最终供应商名称: "${supplierName}"`);
          if (!supplierName || supplierName.trim() === '' || supplierName === 'undefined') {
            this.ctx.logger.warn(`第${rowIndex}行供应商名称为空`);
            errors.push(`第${rowIndex}行: 供应商名称为必填字段`);
            continue;
          }
        
          // 验证供应商名称唯一性
          const existingSupplier = await this.ctx.model.SupplierModel.findOne({
            where: { name: supplierName.trim() }
          });
        
          if (existingSupplier) {
            errors.push(`第${rowIndex}行: 供应商名称 ${supplierName} 已存在`);
            continue;
          }
        
          // 构造供应商数据
          const supplierData = {
            name: supplierName.trim(),
            contactPerson: '',
            phone: '',
            email: '',
            address: '',
            status: 'pending',
            remark: '',
            cooperationDate: null
          };
        
          // 根据字段映射关系更新数据
          this.ctx.logger.info('开始根据字段映射关系更新数据');
          if (Object.keys(fieldMapping).length > 0) {
            // 根据映射关系设置字段值
            for (const [sourceColumn, targetField] of Object.entries(fieldMapping)) {
              const value = row[sourceColumn] || '';
              this.ctx.logger.info(`处理映射: "${sourceColumn}" -> "${targetField}", 值: "${value}"`);
              // 跳过"undefined"字符串
              if (value === 'undefined') {
                this.ctx.logger.info(`跳过undefined值: "${sourceColumn}" -> "${targetField}"`);
                continue;
              }
              
              switch (targetField) {
                case 'name':
                  supplierData.name = value.trim();
                  this.ctx.logger.info(`设置name字段: "${supplierData.name}"`);
                  break;
                case 'contactPerson':
                  supplierData.contactPerson = value;
                  this.ctx.logger.info(`设置contactPerson字段: "${supplierData.contactPerson}"`);
                  break;
                case 'phone':
                  supplierData.phone = value;
                  this.ctx.logger.info(`设置phone字段: "${supplierData.phone}"`);
                  break;
                case 'email':
                  supplierData.email = value;
                  this.ctx.logger.info(`设置email字段: "${supplierData.email}"`);
                  break;
                case 'address':
                  supplierData.address = value;
                  this.ctx.logger.info(`设置address字段: "${supplierData.address}"`);
                  break;
                case 'status':
                  supplierData.status = value;
                  this.ctx.logger.info(`设置status字段: "${supplierData.status}"`);
                  break;
                case 'remark':
                  supplierData.remark = value;
                  this.ctx.logger.info(`设置remark字段: "${supplierData.remark}"`);
                  break;
                case 'cooperationDate':
                  supplierData.cooperationDate = value || null;
                  this.ctx.logger.info(`设置cooperationDate字段: "${supplierData.cooperationDate}"`);
                  break;
                default:
                  this.ctx.logger.info(`未知字段: "${targetField}"`);
              }
            }
          }
          
          this.ctx.logger.info(`第${rowIndex}行数据处理完成:`, supplierData);
          validSuppliers.push(supplierData);
          
          // 更新处理计数
          processedCount++;
          
          // 每处理batchSize条记录就批量插入一次
          if (validSuppliers.length >= batchSize) {
            this.ctx.logger.info(`达到批次大小${batchSize}，开始批量插入`);
            await this.ctx.model.SupplierModel.bulkCreate(validSuppliers);
            this.ctx.logger.info(`批量插入完成，已处理${processedCount}条记录`);
            validSuppliers.length = 0; // 清空数组
          }
        } catch (rowError) {
          this.ctx.logger.error(`处理第${rowIndex}行数据时出错:`, rowError);
          errors.push(`第${rowIndex}行: 数据格式错误 - ${rowError.message}`);
        }
      }
      
      // 插入剩余的供应商数据
      if (validSuppliers.length > 0) {
        this.ctx.logger.info(`插入剩余的${validSuppliers.length}条记录`);
        await this.ctx.model.SupplierModel.bulkCreate(validSuppliers);
        processedCount += validSuppliers.length;
        this.ctx.logger.info(`剩余记录插入完成，总计处理${processedCount}条记录`);
      }
      
      this.ctx.logger.info('数据验证完成，有效数据:', processedCount, '错误数:', errors.length);
      
      // 如果有错误，返回错误信息
      if (errors.length > 0) {
        // 删除临时文件
        if (tempFilePath && fs.existsSync(tempFilePath)) {
          fs.unlinkSync(tempFilePath);
        }
        
        throw new Error(`导入失败: \n${errors.join('\n')}`);
      }
      
      // 删除临时文件
      if (tempFilePath && fs.existsSync(tempFilePath)) {
        fs.unlinkSync(tempFilePath);
      }
      
      // 记录导入完成时间
      const endTime = Date.now();
      const duration = endTime - startTime;
      this.ctx.logger.info(`导入完成，耗时: ${duration}ms`);
      
      return {
        importedCount: processedCount,
        errorCount: errors.length,
        duration: duration
      };
    } catch (error) {
      this.ctx.logger.error('导入供应商失败:', error);
      // 确保临时文件被删除，即使出现错误
      try {
        if (tempFilePath && fs.existsSync(tempFilePath)) {
          fs.unlinkSync(tempFilePath);
        }
      } catch (cleanupError) {
        this.ctx.logger.error('清理临时文件失败:', cleanupError);
      }
    
      throw new Error(`导入供应商失败: ${error.message}`);
    }
  }

  /**
   * 导入供应商模板
   */
  async exportTemplate() {
    try {
      // 创建工作簿
      const workbook = XLSX.utils.book_new();
      
      // 创建模板数据
      const templateData = [
        {
          '供应商名称': '示例供应商',
          '联系人': '张经理',
          '联系电话': '13800138000',
          '邮箱': 'zhang@example.com',
          '地址': '北京市朝阳区示例街道100号',
          '状态': 'pending',
          '合作时间': '2025-01-01',
          '备注': '示例供应商备注'
        }
      ];
      
      // 创建工作表
      const worksheet = XLSX.utils.json_to_sheet(templateData);
      
      // 添加工作表到工作簿
      XLSX.utils.book_append_sheet(workbook, worksheet, '供应商导入模板');
      
      // 写入缓冲区并返回
      const buffer = XLSX.write(workbook, { type: 'buffer', bookType: 'xlsx' });
      return buffer;
    } catch (error) {
      this.ctx.logger.error('生成导入模板失败:', error);
      throw new Error(`生成导入模板失败: ${error.message}`);
    }
  }

  /**
   * 获取供应商统计信息
   */
  async getSupplierStats() {
    try {
      // 添加组织过滤条件
      const orgWhere = {};
      if (this.ctx.state.organizationId) {
        orgWhere.organizationId = this.ctx.state.organizationId;
      } else {
        orgWhere.organizationId = 1; // 默认组织ID
      }

      // 获取供应商总数
      const total = await this.ctx.model.SupplierModel.count({
        where: orgWhere
      });
      
      // 获取各状态的供应商数量
      const statusStats = await this.ctx.model.SupplierModel.findAll({
        attributes: [
          'status',
          [this.ctx.app.Sequelize.fn('COUNT', this.ctx.app.Sequelize.col('id')), 'count']
        ],
        where: orgWhere,
        group: ['status']
      });
      
      // 转换为对象格式
      const statusCount = {};
      statusStats.forEach(item => {
        statusCount[item.status] = parseInt(item.getDataValue('count'));
      });
      
      // 获取最近一周新增的供应商数量
      const oneWeekAgo = new Date();
      oneWeekAgo.setDate(oneWeekAgo.getDate() - 7);
      
      const recentCount = await this.ctx.model.SupplierModel.count({
        where: {
          ...orgWhere,
          createdAt: {
            [this.ctx.app.Sequelize.Op.gte]: oneWeekAgo
          }
        }
      });
      
      // 计算高风险供应商数量
      // 高风险供应商定义为：评分低于3.0的活跃供应商
      const riskSuppliers = await this.ctx.model.SupplierModel.count({
        where: {
          ...orgWhere,
          status: 'active',
          rating: {
            [this.ctx.app.Sequelize.Op.lt]: 3.0
          }
        }
      });
      
      return {
        total,
        status: statusCount,
        recent: recentCount,
        risk: riskSuppliers
      };
    } catch (error) {
      this.ctx.logger.error('获取供应商统计信息失败:', error);
      // 如果是数据库连接错误，返回模拟统计信息
      if (error.name === 'SequelizeConnectionRefusedError' || 
          error.name === 'SequelizeAccessDeniedError' ||
          error.name === 'SequelizeHostNotFoundError') {
        this.ctx.logger.warn('数据库连接失败，返回模拟统计信息');
        return {
          total: 2,
          status: {
            'active': 1,
            'pending': 1
          },
          recent: 0,
          risk: 0
        };
      }
      // 返回默认统计信息而不是抛出错误
      return {
        total: 0,
        status: {},
        recent: 0,
        risk: 0
      };
    }
  }
}

module.exports = SupplierService;